\documentclass[12pt,a4paper,utf8x]{report}
\usepackage[utf8]{inputenc} % un package
\usepackage[T1]{fontenc}      % un second package
\usepackage[francais]{babel}  % un troisième package
\usepackage{graphicx}
\usepackage{listings}

\usepackage {geometry}

% Pour mettre du code source
\usepackage {listings}

\usepackage{verbatim}
\usepackage{fancyvrb}
% Pour pouvoir passer en paysage
\usepackage{lscape}

% Pour pouvoir faire plusieurs colonnes
\usepackage {multicol}
\usepackage{pifont}


% Pour l'interligne de 1.5
\usepackage {setspace}
% Pour les marges de la page
\geometry{a4paper, top=2.5cm, bottom=2.5cm, left=3cm, right=2.5cm, marginparwidth=1.2cm}

\parskip=5pt %% distance entre § (paragraphe)
\sloppy %% respecter toujours la marge de droite 

% Pour les pénalités :
\interfootnotelinepenalty=150 %note de bas de page
\widowpenalty=150 %% veuves et orphelines
\clubpenalty=150 

%Pour la longueur de l'indentation des paragraphes
\setlength{\parindent}{15mm}



%%%% debut macro pour enlever le nom chapitre %%%%
\makeatletter
\def\@makechapterhead#1{%
 % \vspace*{30\p@}%
  {\parindent \z@ \raggedright \normalfont
    \interlinepenalty\@M
    \ifnum \c@secnumdepth >\m@ne
        \Huge\bfseries \thechapter\quad
    \fi
    \Huge \bfseries #1\par\nobreak
    \vskip 20\p@
  }}

\def\@makeschapterhead#1{%
%  \vspace*{30\p@}%
  {\parindent \z@ \raggedright
    \normalfont
    \interlinepenalty\@M
    \Huge \bfseries  #1\par\nobreak
    \vskip 20\p@
  }}
\makeatother
%%%% fin macro %%%%

\title{RGL, tests et interactions}
\author{Julien Henry}
\date{13 Main 2013}

\begin{document}

\maketitle

\newpage
\chapter{Explorer3d et OpenGL}
\section{L'interaction souris}
\paragraph{}
Au sein d'Explorer3d la partie OpenGL permet de visualiser, mais aussi de manipuler les éléments présents dans la scène afin de mieux visualiser les différents éléments. Ces éléments qui permettent d'intéragir avec la scène sont en partie intégrée dans RGL de façon native. En effet les évènements liés à la souris sont par défaut liés aux rotations dans la scène ainsi qu'au zoom et dé-zoom.

\paragraph{}
Cependant, la sélection d'éléments afin de les isoler ou pouvoir les étudier séparément n'est pas implanté dans la fenêtre de base de RGL. Il était donc essentiel de vérifier si des outils permettant ce genre d'interactions existaient. Et si oui comment fonctionnaient-ils afin de pouvoir les intégrer à un projet plus imposant, notament à une interface RGtk2.

\begin{center}
\includegraphics[scale=0.3]{sel_exp.png}\\
\textit{selection d'éléments au sein d'exlorer3d}
\end{center}


\newpage
\section{Intro au tuto}
\paragraph{}
Cette partie se concentrera sur l'aspect RGL (des scènes 3d donc) du portage sous R d'Explorer3d.

\paragraph{}
Dans les pages qui suivent nous allons détailler quels sont les outils présents afin de réaliser des interactions entre l'utilisateur et RGL. Nous verrons également quels sont les documents et tutoriels trouvables dans RGL et sur le net ainsi que les fonctionnalités que nous pourront ré-utiliser. Enfin nous verrons quelques exemples simples d'application intégrant RGL et RGtk2.

\paragraph{}
Afin de pouvoir comparer les différents éléments que nous avons put trouver, nous prendrons comme exemple réccurent un nombre de 1000 sphère ou points affichés dans la scène de RGL.

\paragraph{}
Egalement nous préciserons plusieurs points techniques qui nous ont facilités l'utilisation de l'interaction de la fenetre RGL. Il s'agira là toutefois d'exemple illustrant ce qui est possible de faire avec cet outils. D'autres solutions sont possibles et nous les aborderons, mais nous pensons qu'elles ne sont pas à privilégier.


\newpage
\chapter{RGL : Interactions}
\section{Les outils fournis par RGL}


\paragraph{} Au sein de rgl l'évènement par défaut pour le click droit est lié au zoom et dézoom de la scène, le click gauche à la rotation de la scène.

\paragraph{}
Néanmoins nous avons trouvés deux fonctions déjà intégrée au sein de rgl permettant d'effectuer des sélection au sein de la scène 3d via la souris.

\subsection{Select3d}
\paragraph{} Cette fonction est bloquante. Elle renvoi une fonction de vecteurs (x,y,z) contenant les coordonnées des points où sélectionnés par l'utilisateur. 
\\ \\
voir http://www.inside-r.org/packages/cran/rgl/docs/select3d

\paragraph{}
voici un code d'exemple d'utilisation de select3d : \\

\begin{lstlisting}
	x <- rnorm(1000)
	y <- rnorm(1000)
	z <- rnorm(1000)
	open3d()
	points3d(x,y,z)
	f <- select3d()
	keep <- f(x,y,z)
	rgl.pop()
	points3d(x[keep],y[keep],z[keep],color="red")
	points3d(x[!keep],y[!keep],z[!keep])
\end{lstlisting} 

\paragraph{}
Dans cet exemple nous chargeons une scene 3d avec un nuage de points. L'appel a select3d est bloquant jusqu'a ce que l'utilisateur effectue une sélection dans le nuage de points. Il recharge ensuite le nuage, colorant en rouge la selection effectuee.

\paragraph{}
Il est donc possible de sélectionner des objets dans une fenêtre rgl.

\newpage
\subsection{Selectpoints3d}
\paragraph{} Cette fonction est également bloquante. Elle attends en paramètres la liste complète des éléments présents dans la scène. Elle utilise ensuite la fonction select3d pour déterminer quels éléments sont dans la sélection et les renvoyer. Elle permet également de selectionner non pas une région de la scène mais un point précis.
\\ \\
voir http://www.inside-r.org/packages/cran/rgl/docs/selectpoints3d

\paragraph{}
voici un code d'exemple d'utilisation de selectpoints3d  : 

\begin{lstlisting}
	ids <- plot3d( rnorm(20), rnorm(20), rnorm(20) )
  
	selectpoints3d(ids["data"], 
		multiple = function(x) {
		spheres3d(x, color = "red", alpha = 0.3, radius = 0.2)
		TRUE
	})
\end{lstlisting}

\vspace{1cm}

\begin{center}
\includegraphics[scale=0.7]{selectpoints3d.png}\\
\textit{Selection de 5 sphères dans rgl via Selectpoints3d}
\end{center}

\paragraph{}
Néanmoins, après plusieurs tests, il apparait que cette fonction ne permet pas de sélectionner un élément unique lorsque la scène est par exemple composée de sphères ou de nuages de points non définis par plot3d, ce qui se révèle assez problématique pour avoir un code souple. 


\newpage
\section{RGL - Sculpt3d}

\paragraph{}
Il existe également un package pour rgl qui permet de simplifier la sélection de divers objets de la fenêtre rgl. Celui-ci inclus une toolbar rgtk afin de nottament résoudre le problème de conflits sur l'évenement de clic gauche de la souris - fonctions bloquantes et impossibilités de rappel de la fonction. En sélectionnant l'option adéquat dans la barre rgtk l'utilisateur peut réactiver à loisir la sélection d'objets 3d, la fonction de rotation reprenant la priorité sur la sélection après chaque utilisation.

\paragraph{}
Voici le code R appelé lors de l'execution du fichier de démo de sculpt3d : \\ \\ \\ \\


\begin{lstlisting}
x <- sort(rnorm(1000))
y <- rnorm(1000)
z <- rnorm(1000) + atan2(x,y)
sculpt3d(x, y, z, col=rainbow(1000), 
	type='s', alpha = .5, radius = runif(1000)/5)
\end{lstlisting}

\vspace{5mm}

\begin{center}
\includegraphics[scale=0.2]{sculpt3d.png}\\
\textit{Selection d'une région dans sculpt3d}
\end{center}

\paragraph{}
Celui-ci charge la barre d'outils ainsi qu'une fênetre rgl contenant 1000 élèments de différentes couleurs.

\paragraph{}
Cette barre d'outils inclus également plusieurs options, tels que la suppression des éléments actuellement sélectionnés, la re-coloration des éléments sélectionnés et l'isolation des éléments sélectionnés.

\paragraph{}
Ce package rempli ainsi une partie des interactions principales présentes dans explorer3d, excepté la loupe. Ses fonctionalités ne peuvent cependant pas être intégrées en une seule fenêtre sans modifier le code source du package.

\paragraph{}
Le code source de Sculpt3d est accessible et les autres fonctionnalités d'Explorer3d pourraient donc y être ajoutées, comme l'explorateur de fichiers par exemple. Cela impliquerait de coder cette intégration, mais c'est une tâche qui peut être réalisée, bien que fastidieuse.

\paragraph{}
Nous avons également cherché d'autres outils pouvant servir d'alternatives à sculpt3d, mais il apparaît que ce package a actuellement le monopole de ce type de fonctionnalités. Les tutoriels basés sur ce package étant assez peu nombreux, pour ne pas dire inexistant hormis la brève documentation fournie, il est nécessaire d'étudier le code source du package afin de ne pas avoir à ré-inventer du code déjà existant.

%\newpage
\section{RGL et RGtk2}
\paragraph{}
Après avoir étudié le code source de Select3d, il apparait que seule la fonction select3d est utilisée dans ce package, probablement pour des raisons de portabilités. Entre select3d et selectpoints3d c'est également la première fonction que nous recommandons d'utiliser afin de pouvoir interagir avec la scène. 

\paragraph{}
Un autre avantage de select3d est apparu lors des tests d'interaction entre rgl et rgtk2. Selectpoints3d supporte mal la cohabitation, et les selections réalisées ne sont pas actualisées correctement.

\paragraph{}
Voici donc deux exemples légers réalisés, imitant le principe de Sculpt3d : une fenetre rgtk2 qui permet de faire apparaitre la scène et d'activer la sélection.
\\ \\
\begin{center}
\includegraphics[scale=0.5]{nuage.png}\\
\textit{Selection d'un nuage de points via rgtk2}
\end{center}

\vspace{1cm}

\begin{center}
\includegraphics[scale=0.5]{spheres.png}\\
\textit{Selection de spheres via rgtk2}
\end{center}

\paragraph{}
Et voici le code permettant d'interagir avec les fonctions de rgtk2 comme l'illustre la capture d'écran précédente :
\\ \\
\begin{center}
\includegraphics[scale=0.5]{ext_1.png}\\
\textit{Aperçu des fonctions d'interaction}
\end{center}

\paragraph{}
En complexifiant l'exemple précédent, nous pouvons commencer à nous rapprocher d'outils présent au sein d'Explorer3d, comme par exemple avoir les objets sélectionnés dans une vue et les objets non sélectionnés dans une seconde.

\paragraph{}
Via la conservation des identifiants des differentes fenetres au sein d'une variable globale offrant une similitude avec les langages orientés objets. Ainsi il est possible de gérer plusieurs fenêtres et d'interagir avec celles-ci, le tout paramétré par l'outil rgtk2.
\\ \\
\begin{center}
\includegraphics[scale=0.5]{doublefen.png}\\
\textit{Interactions entre RGL et RGtk2}
\end{center}
\vspace{1cm}

\paragraph{}
En exploitant l'environnement global, il est simple de gérer les fenetres affichées et de savoir quelle est la fenetre active : 

\begin{lstlisting}
# declaration de l'environnement
.monEnv <- new.env()

# stockage dans l'environnement de l'identifiant de la fenetre 
# rgl a l'ouverture de celle-ci
.monEnv$idfen <- open3d() 

# charge comme fenetre active la fenetre dont l'identifiant
# a auparavant ete stocke dans l'environnement
rgl.set(.monEnv$idfen)
\end{lstlisting}

\newpage
\section{Problèmes RGL à éviter}
\subsection{Selection vide}
\paragraph{} Un problème auquel nous avons été confronté lors des études d'interaction avec RGL a été l'apparition d'erreurs lors de l'affichage des sphères. En effet, lorsque l'utilisateur effectue une sélection vide dans la scène RGL, des vecteurs vides sont transmis aux fonctions d'affichage ce qui entraine ces problèmes.

\paragraph{}
C'est pourquoi il est nécessaire lors de la sélection de select3d de vérifier que celle-ci comporte au moins un élèment (ou de vérifier lors de chaque affichage d'objets que les vecteurs transmis ne sont pas vide).

\subsection{Affichage en multi-vues}
\paragraph{} Comme nous en avons parlés dans la section précédente lorsque nous présentions l'interaction entre rgl et rgtk2, il est nécessaire de gérer les scènes rgl afin de ne pas créer de nouvelles fenêtres a chaque évenements. La fonction rgl.pop() qui permet de vider une scène courante est alors à utiliser avant de charger à nouveau les éléments attendus dans la scène concernée.

\section{Sources}
\paragraph{}
Il n'y a aucun tutoriel en ligne en dehors de la documentation RGL et de la documentation de Sculpt3d. La majeure partie des expérimentations d'interactions avec la scène RGL ont été effectuées en expérimentant à la volée des tests de sélection et d'interaction. Le code-source de Scultp3d, bien que complexe, a toutefois permit de cerner certaines spécificités de ce genre d'interactions.
\\ \\
http://cran.r-project.org/web/packages/rgl/rgl.pdf
\\ \\
http://www.inside-r.org/packages/cran/sculpt3d

\newpage
\chapter{Loupe et perfs}
\section{Loupe}
\paragraph{}
Un outils spécifique à Explorer3d et très apprécié par ses concepteurs est la présence d'une loupe permettant d'avoir un aperçu préci d'une région de la scène 3d. Cette loupe permet nottament de sélectionner et visualiser plus précisément des éléments tout en continuant à naviguer dans la scène. 
\\ \\

\begin{center}
\includegraphics[scale=0.5]{loupe_exp.png}\\
\textit{Aperçu de la loupe d'Explorer3d}
\end{center}
\vspace{1cm}

\paragraph{}
Nous avons étudiés les outils proposés par RGL et RGtk2 afin de pouvoir reproduire cette loupe ou du moins une alternative. Il apparait que la méthode utilisée au sein d'Explorer3d, à savoir réaliser une copie en deux dimensions de la scène 3d et effectuer des altérations sur cette image, peut en partie être imitée sous R. En effet, RGL possède une fonction rgl.snapshot("loupe.png") qui permet d'enregistrer une capture d'écran de la fenêtre sous le nom de fichier passé en paramètre. Néanmoins RGL ne permet pas d'utiliser les images en deux dimensions comme nous souhaitons le faire. 

\paragraph{}
Nous nous sommes tournés vers RGtk2 qui offre quelques fonctionnalités de gestion d'images. Au final nous pouvons faire apparaitre l'image prise par RGL dans une fenêtre RGtk2, mais les possibilités sont là-aussi limitées. Il existe des outils sous R qui permettent de manipuler efficacement les images mais celles-ci nécessitent d'utiliser d'autres librairies que nous n'avons pas eu le temps d'étudier en détail.

\paragraph{}
Nous avons toutefois effectués quelques recherches pour déterminer quelles librairies seraient susceptibles de convenir à un développement approfondit. EBImage semble au final être un package offrant des fonctionnalités qui pourraient convenir.

\paragraph{}
Pour pouvoir porter la loupe sous R, plusieurs fonctionnalités sont nécessaires. Certaines d'entre elles existent, mais elles impliquent d'effectuer des modification dans le code source même de RGL et probablement aussi de RGtk2. 
\vspace{5mm}


\begin{center}
\includegraphics[scale=0.5]{loupe_r.png}\\
\textit{Aperçu de l'ébauche d'une loupe portée sous R}
\end{center}
\vspace{1cm}

\begin{lstlisting}
rgl.snapshot("loupe.png")
fenetre2 = gtkWindow()
img = gtkImageNewFromFile("loupe.png")
fenetre2$title="Test loupe"
superpanel2 = gtkVBoxNew(FALSE,8)
frame2=gtkFrameNew()
fenetre2$add(frame2)
frame2$add(superpanel2)
superpanel2$packStart(img,FALSE,FALSE,0)
\end{lstlisting}

\paragraph{}
Voici l'extrait de code permettant d'afficher la capture d'écran RGL dans une fenêtre RGtk2. Nous sommes à présent limités par RGL et RGtk2. Pour avancer plus loin dans le développement de la loupe il faudrait effectuer des modifications dans les codes sources R de RGL et RGtk2. 

\paragraph{}
Nous avons localisés les fonctions concernées afin que les développeurs futurs qui seront amenés à travailler sur ce portage n'aient pas à effectuer cette recherche. Toutefois réaliser cette application risque d'être complexe.

\paragraph{}
Voici les fonctions utiles en question qu'il faudrait réutiliser et/ou modifier afin de pouvoir porter la loupe sur R :

\begin{lstlisting}
# RGTK :
#renvoi les coordonnees de la souris par rapport
# a la fenetre rgtk (coin haut gauche)
pos <- gdkWindowGetPointer(fenetre2)		
# pos$x et pos$y sont accessibles
	
# renvoi la position de la fenetre RGtk2
# par rapport au bureau de l'utilisateur
# (coin haut gauche)
gtkWindowSetGravity(fenetre2,"north-west")
pos<-gtkWindowGetPosition(fenetre2)
#stocke les coordonnees dans pos$root.x et pos$root.y

# RGL :
# renvoi les coordonnees de la souris par rapport
# a la fenetre RGL
select3d->rgl.select3d->rgl.select->rgl.selectstate->rgl_setselectstate.c 

# stocke la position des angles de la fenetre rgl
# par rapport au bureau de l'utilisateur
open3d()
pos<-par3d("windowRect")

\end{lstlisting}

\newpage
\section{Performances de RGL}
\paragraph{}
Au sein d'Explorer3d il est courant d'afficher sur la scène OpenGL un nombre très important d'objets. Ainsi nous savons qu'Explorer3d est cappable d'afficher facilement plus de 60 000 sphères tout en conservant des performances acceptables.

\paragraph{}
Nous savions avant d'entamer ces recherches en portabilité sous R que nous aurions difficilement les mêmes performances. Avant d'avoir des estimations précises des capacités de RGL nous avons effectués une batterie de tests. Nous avons simplement augmentés le nombre de sphères à afficher dans la fenêtre jusqu'à atteindre les limites de RGL.\\ \\

\begin{tabular}{|l|c|r|}
  \hline
  1000 sphères & performances acceptables \\
  \hline
  5000 sphères & temps de chargements longs et navigation fluide\\
  \hline
  10 000 sphères & temps de chargements longs et navigation saccadée\\
  \hline
  20 000 sphères & temps de chargements de plus de 15s et navigation difficile\\
  \hline
  60 000 sphères & temps de chargements supérieurs à 45s\\
  \hline
\end{tabular}

\paragraph{}
Une lecture rapide des résultats permet de se rendre compte que R est effectivement beaucoup moins performant que java pour utiliser l'OpenGL (au moins quatre fois moins performant).

\paragraph{}
Il faut cependant garder en mémoire que nous n'avons pas effectués de recherches destinées à optimiser les performances de RGL, par exemple en diminuant le nombre de facettes affichées ou en diminuant le nombre d'images par secondes.


\newpage
\chapter{Portage de Explorer3d}
\section{Les limites de RGL}
\paragraph{}
Un problème majeur qui apparait à ce point est qu'une fonctionnalité importante d'Explorer3d ne pourra pas être reproduite en R. En effet sous Explorer3d deux types de sélection d'éléments existent : la sélection de région d'éléments et la sélection d'un unique élément. Comme nous avons pu le voir  la sélection d'un élément unique est gérée dans RGL par Selectpoints3d. Or Selectpoints3d ne permet pas une selection individuelle d'éléments différents de plots3d, ce qui ne correspond pas aux spécificités que nous recherchons pour porter Explorer3d sous R.

\paragraph{}
Une solution à ce problème serait de surcoucher une nouvelle fonction de sélection via Select3d. Ainsi, par exemple, lors d'un événement défini une selection via Select3d serait effectuée sur une zone très rèduite autour de l'unique élément ciblé. Théoriquement cette fonctionnalité est réalisable. L'inconvénient est qu'il n'y aurait pas un unique élément sélectionné, mais tout les éléments compris dans cette même sélection (alignés en profondeur avec l'élément ciblé).







\chapter{VG notes }
reste a faire : \\
	portage R -> rgl ? rgtk ? en cours\\
	description technique des extensions logicielles : a réaliser\\

\end{document}






